home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 2 / Atari Mega Archive CD - Volume 2.iso / minix / up1510b.tgz / up1510b / src / kernel / system.c < prev    next >
C/C++ Source or Header  |  1990-07-23  |  33KB  |  959 lines
  1. /* This task handles the interface between file system and kernel as well as
  2.  * between memory manager and kernel.  System services are obtained by sending
  3.  * sys_task() a message specifying what is needed.  To make life easier for
  4.  * MM and FS, a library is provided with routines whose names are of the
  5.  * form sys_xxx, e.g. sys_xit sends the SYS_XIT message to sys_task.  The
  6.  * message types and parameters are:
  7.  *
  8.  *   SYS_FORK     informs kernel that a process has forked
  9.  *   SYS_NEWMAP     allows MM to set up a process memory map
  10.  *   SYS_EXEC     sets program counter and stack pointer after EXEC
  11.  *   SYS_XIT     informs kernel that a process has exited
  12.  *   SYS_GETSP     caller wants to read out some process' stack pointer
  13.  *   SYS_TIMES     caller wants to get accounting times for a process
  14.  *   SYS_ABORT     MM or FS cannot go on; abort MINIX
  15. #if (CHIP == M68000)
  16.  *   SYS_FRESH     start with a fresh process image during EXEC
  17. #endif
  18.  *   SYS_SIG     send a signal to a process
  19.  *   SYS_KILL     cause a signal to be sent via MM
  20.  *   SYS_COPY     requests a block of data to be copied between processes
  21.  *   SYS_GBOOT     copies the boot parameters to a process
  22.  *   SYS_UMAP     compute the physical address for a given virtual address
  23.  *   SYS_MEM     returns the next free chunk of physical memory 
  24.  *   SYS_TRACE     request a trace operation
  25.  *
  26.  * Message type m1 is used for all except SYS_SIG and SYS_COPY, both of
  27.  * which need special parameter types.
  28.  *
  29.  *    m_type       PROC1     PROC2      PID     MEM_PTR   
  30.  * ------------------------------------------------------
  31.  * | SYS_FORK   | parent  |  child  |   pid   |         |
  32.  * |------------+---------+---------+---------+---------|
  33.  * | SYS_NEWMAP | proc nr |         |         | map ptr |
  34.  * |------------+---------+---------+---------+---------|
  35.  * | SYS_EXEC   | proc nr | traced  | new sp  |         |
  36.  * |------------+---------+---------+---------+---------|
  37.  * | SYS_XIT    | parent  | exitee  |         |         |
  38.  * |------------+---------+---------+---------+---------|
  39.  * | SYS_GETSP  | proc nr |         |         |         |
  40.  * |------------+---------+---------+---------+---------|
  41.  * | SYS_TIMES  | proc nr |         | buf ptr |         |
  42.  * |------------+---------+---------+---------+---------|
  43.  * | SYS_ABORT  |         |         |         |         |
  44. #if (CHIP == M68000)
  45.  * |------------+---------+---------+---------+---------|
  46.  * | SYS_FRESH  | proc nr | data_cl |         |         |
  47. #endif
  48.  * |------------+---------+---------+---------+---------|
  49.  * | SYS_GBOOT  | proc nr |         |         | bootptr |
  50.  * ------------------------------------------------------
  51.  *
  52.  *
  53.  *    m_type       m2_i1     m2_i2     m2_l1     m2_l2     
  54.  * ------------------------------------------------------
  55.  * | SYS_TRACE  | proc_nr | request |  addr   |  data   |
  56.  * ------------------------------------------------------
  57.  *
  58.  *
  59.  *    m_type       m6_i1     m6_i2     m6_i3     m6_f1     
  60.  * ------------------------------------------------------
  61.  * | SYS_SIG    | proc_nr  |  sig    |         | handler |
  62.  * ------------------------------------------------------
  63.  * | SYS_KILL   | proc_nr  |  sig    |         |         |
  64.  * ------------------------------------------------------
  65.  *
  66.  *
  67.  *    m_type      m5_c1   m5_i1    m5_l1   m5_c2   m5_i2    m5_l2   m5_l3
  68.  * --------------------------------------------------------------------------
  69.  * | SYS_COPY   |src seg|src proc|src vir|dst seg|dst proc|dst vir| byte ct |
  70.  * --------------------------------------------------------------------------
  71.  * | SYS_UMAP   |  seg  |proc nr |vir adr|       |        |       | byte ct |
  72.  * --------------------------------------------------------------------------
  73.  *
  74.  *
  75.  *    mem_type    DEVICE    PROC_NR    COUNT   POSITION
  76.  * |------------+---------+---------+---------+---------|
  77.  * | SYS_MEM    | extflag |         |mem size |mem base |
  78.  * ------------------------------------------------------
  79.  *
  80.  * In addition to the main sys_task() entry point, there are 5 other minor
  81.  * entry points:
  82.  *   cause_sig:    take action to cause a signal to occur, sooner or later
  83.  *   inform:    tell MM about pending signals
  84.  *   numap:    umap D segment starting from process number instead of pointer
  85.  *   umap:    compute the physical address for a given virtual address
  86.  *   alloc_segments: allocate segments for 8088 or higher processor
  87.  */
  88.  
  89. #include "kernel.h"
  90. #include <signal.h>
  91. #include <minix/boot.h>
  92. #include <minix/callnr.h>
  93. #include <minix/com.h>
  94. #include "proc.h"
  95. #if (CHIP == INTEL)
  96. #include "protect.h"
  97. #endif
  98.  
  99. PRIVATE message m;
  100. PRIVATE char sig_stuff[SIG_PUSH_BYTES];    /* used to send signals to processes */
  101.  
  102. FORWARD int do_abort();
  103. FORWARD int do_copy();
  104. FORWARD int do_exec();
  105. FORWARD int do_fork();
  106. FORWARD int do_gboot();
  107. FORWARD int do_getsp();
  108. FORWARD int do_kill();
  109. FORWARD int do_mem();
  110. FORWARD int do_newmap();
  111. FORWARD int do_sig();
  112. FORWARD int do_times();
  113. FORWARD int do_trace();
  114. FORWARD int do_umap();
  115. FORWARD int do_xit();
  116. #if (CHIP == M68000)
  117. FORWARD void build_sig();
  118. #endif
  119.  
  120. /*===========================================================================*
  121.  *                sys_task                     *
  122.  *===========================================================================*/
  123. PUBLIC void sys_task()
  124. {
  125. /* Main entry point of sys_task.  Get the message and dispatch on type. */
  126.  
  127.   register int r;
  128.  
  129.   while (TRUE) {
  130.     receive(ANY, &m);
  131.  
  132.     switch (m.m_type) {    /* which system call */
  133.         case SYS_FORK:    r = do_fork(&m);    break;
  134.         case SYS_NEWMAP:    r = do_newmap(&m);    break;
  135.         case SYS_EXEC:    r = do_exec(&m);    break;
  136.         case SYS_XIT:    r = do_xit(&m);        break;
  137.         case SYS_GETSP:    r = do_getsp(&m);    break;
  138.         case SYS_TIMES:    r = do_times(&m);    break;
  139.         case SYS_ABORT:    r = do_abort(&m);    break;
  140. #if (CHIP == M68000)
  141.         case SYS_FRESH:    r = do_fresh(&m);    break;
  142. #endif
  143.         case SYS_SIG:    r = do_sig(&m);        break;
  144.         case SYS_KILL:    r = do_kill(&m);    break;
  145.         case SYS_COPY:    r = do_copy(&m);    break;
  146.         case SYS_GBOOT:    r = do_gboot(&m);    break;
  147.         case SYS_UMAP:    r = do_umap(&m);    break;
  148.         case SYS_MEM:    r = do_mem(&m);        break;
  149.         case SYS_TRACE:    r = do_trace(&m);    break;
  150.         default:        r = E_BAD_FCN;
  151.     }
  152.  
  153.     m.m_type = r;        /* 'r' reports status of call */
  154.     send(m.m_source, &m);    /* send reply to caller */
  155.   }
  156. }
  157.  
  158.  
  159. /*===========================================================================*
  160.  *                do_fork                         * 
  161.  *===========================================================================*/
  162. PRIVATE int do_fork(m_ptr)
  163. register message *m_ptr;    /* pointer to request message */
  164. {
  165. /* Handle sys_fork().  m_ptr->PROC1 has forked.  The child is m_ptr->PROC2. */
  166.  
  167. #if (CHIP == INTEL)
  168.   reg_t old_ldt_sel;
  169. #endif 
  170.   register struct proc *rpc;
  171.   struct proc *rpp;
  172.  
  173.   if (!isoksusern(m_ptr->PROC1) || !isoksusern(m_ptr->PROC2))
  174.     return(E_BAD_PROC);
  175.   rpp = proc_addr(m_ptr->PROC1);
  176.   rpc = proc_addr(m_ptr->PROC2);
  177.  
  178.   /* Copy parent 'proc' struct to child. */
  179. #if (CHIP == INTEL)
  180.   old_ldt_sel = rpc->p_ldt_sel;    /* stop this being obliterated by copy */
  181.   *rpc = *rpp;
  182.   rpc->p_ldt_sel = old_ldt_sel;
  183. #else
  184.   phys_copy( rpp, (phys_bytes)proc_addr(m_ptr->PROC2),
  185.          (phys_bytes)sizeof(struct proc));
  186. #endif 
  187.   rpc->p_nr = m_ptr->PROC2;    /* this was obliterated by copy */
  188.  
  189. #if (CHIP != M68000)
  190.   rpc->p_flags |= NO_MAP;    /* inhibit the process from running */
  191. #endif
  192.   rpc->p_flags &= ~(PENDING | SIG_PENDING | P_STOP);
  193.                 /* only one in group should have PENDING */
  194.                 /* child does not inherit trace status */
  195.   rpc->p_pending = 0;
  196.   rpc->p_pendcount = 0;
  197.   rpc->p_pid = m_ptr->PID;    /* install child's pid */
  198.   rpc->p_reg.retreg = 0;    /* child sees pid = 0 to know it is child */
  199.  
  200.   rpc->user_time = 0;        /* set all the accounting times to 0 */
  201.   rpc->sys_time = 0;
  202.   rpc->child_utime = 0;
  203.   rpc->child_stime = 0;
  204. #if (CHIP == M68000)
  205.   rpc->p_nflips = 0;
  206.   mkshadow(rpp, (phys_clicks)m_ptr->m1_p1);    /* run child first */
  207. #endif
  208.   return(OK);
  209. }
  210.  
  211.  
  212. /*===========================================================================*
  213.  *                do_newmap                     * 
  214.  *===========================================================================*/
  215. PRIVATE int do_newmap(m_ptr)
  216. message *m_ptr;            /* pointer to request message */
  217. {
  218. /* Handle sys_newmap().  Fetch the memory ma